# Copyright (c) 2019 The Johns Hopkins University/Applied Physics Laboratory
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

import six

from kmip.core import enums
from kmip.core import exceptions
from kmip.core import objects
from kmip.core import primitives
from kmip.core import utils
from kmip.core.messages.payloads import base


class ModifyAttributeRequestPayload(base.RequestPayload):
    """
    A request payload for the ModifyAttribute operation.

    Attributes:
        unique_identifier: The unique ID of the object on which attribute
            deletion should be performed.
        attribute: The attribute value to be modified by index. Used in KMIP
            1.0 - 1.4.
        current_attribute: The current attribute to be modified on the
            specified object. Used in KMIP 2.0+.
        new_attribute: The new attribute value to set on the specified object.
            Used in KMIP 2.0+.
    """

    def __init__(self,
                 unique_identifier=None,
                 attribute=None,
                 current_attribute=None,
                 new_attribute=None):
        """
        Construct a ModifyAttribute request payload.

        Args:
            unique_identifier (string): The unique ID of the object on which
                attribute modification should be performed. Optional, defaults
                to None.
            attribute (struct): An Attribute object containing the attribute
                name and index identifying the existing attribute, and the new
                attribute value to replace the original attribute. Optional,
                defaults to None. Used in KMIP 1.0 - 1.4. Required for
                read/write.
            current_attribute (struct): A CurrentAttribute object containing
                the original attribute value on the specified object. Optional,
                defaults to None. Used in KMIP 2.0+.
            new_attribute (struct): A NewAttribute object containing the new
                attribute value to set on the specified object. Optional,
                defaults to None. Used in KMIP 2.0+. Required for read/write.
        """
        super(ModifyAttributeRequestPayload, self).__init__()

        self._unique_identifier = None
        self._attribute = None
        self._current_attribute = None
        self._new_attribute = None

        self.unique_identifier = unique_identifier
        self.attribute = attribute
        self.current_attribute = current_attribute
        self.new_attribute = new_attribute

    @property
    def unique_identifier(self):
        if self._unique_identifier:
            return self._unique_identifier.value
        return None

    @unique_identifier.setter
    def unique_identifier(self, value):
        if value is None:
            self._unique_identifier = None
        elif isinstance(value, six.string_types):
            self._unique_identifier = primitives.TextString(
                value=value,
                tag=enums.Tags.UNIQUE_IDENTIFIER
            )
        else:
            raise TypeError("The unique identifier must be a string.")

    @property
    def attribute(self):
        if self._attribute:
            return self._attribute
        return None

    @attribute.setter
    def attribute(self, value):
        if value is None:
            self._attribute = None
        elif isinstance(value, objects.Attribute):
            self._attribute = value
        else:
            raise TypeError("The attribute must be an Attribute object.")

    @property
    def current_attribute(self):
        if self._current_attribute:
            return self._current_attribute
        return None

    @current_attribute.setter
    def current_attribute(self, value):
        if value is None:
            self._current_attribute = None
        elif isinstance(value, objects.CurrentAttribute):
            self._current_attribute = value
        else:
            raise TypeError(
                "The current attribute must be a CurrentAttribute object."
            )

    @property
    def new_attribute(self):
        if self._new_attribute:
            return self._new_attribute
        return None

    @new_attribute.setter
    def new_attribute(self, value):
        if value is None:
            self._new_attribute = None
        elif isinstance(value, objects.NewAttribute):
            self._new_attribute = value
        else:
            raise TypeError(
                "The new attribute must be a NewAttribute object."
            )

    def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        从输入缓冲区读取ModifyAttribute请求的有效载荷的数据编码，并将其解码为其组成部分。

        参数:
            input_buffer (stream): 包含编码的对象数据的数据流，支持读取方法；通常是BytearrayStream对象。
            kmip_version (KMIPVersion): 定义将用于解码对象的KMIP版本的枚举。可选，默认为KMIP 1.0。

        引发:
            InvalidKmipEncoding: 如果编码中缺少字段，则引发。
        """
        # 调用父类的read方法
        super(ModifyAttributeRequestPayload, self).read(
            input_buffer,
            kmip_version=kmip_version
        )
        # 创建一个本地缓冲区，用于存储从输入缓冲区读取的数据
        local_buffer = utils.BytearrayStream(input_buffer.read(self.length))

        # 如果下一个标签是UNIQUE_IDENTIFIER
        if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_buffer):
            # 创建一个TextString对象，并读取其值
            self._unique_identifier = primitives.TextString(
                tag=enums.Tags.UNIQUE_IDENTIFIER
            )
            self._unique_identifier.read(
                local_buffer,
                kmip_version=kmip_version
            )
        else:
            # 如果没有UNIQUE_IDENTIFIER标签，将_unique_identifier设置为None
            self._unique_identifier = None

        # 如果KMIP版本小于2.0
        if kmip_version < enums.KMIPVersion.KMIP_2_0:
            # 如果下一个标签是ATTRIBUTE
            if self.is_tag_next(enums.Tags.ATTRIBUTE, local_buffer):
                # 创建一个Attribute对象，并读取其值
                self._attribute = objects.Attribute()
                self._attribute.read(local_buffer, kmip_version=kmip_version)
            else:
                # 如果没有ATTRIBUTE标签，抛出InvalidKmipEncoding异常
                raise exceptions.InvalidKmipEncoding(
                    "The ModifyAttribute request payload encoding is missing "
                    "the attribute field."
                )
        else:
            # 如果KMIP版本大于等于2.0
            # 如果下一个标签是CURRENT_ATTRIBUTE
            if self.is_tag_next(enums.Tags.CURRENT_ATTRIBUTE, local_buffer):
                # 创建一个CurrentAttribute对象，并读取其值
                self._current_attribute = objects.CurrentAttribute()
                self._current_attribute.read(
                    local_buffer,
                    kmip_version=kmip_version
                )
            else:
                # 如果没有CURRENT_ATTRIBUTE标签，将_current_attribute设置为None
                self._current_attribute = None

            # 如果下一个标签是NEW_ATTRIBUTE
            if self.is_tag_next(enums.Tags.NEW_ATTRIBUTE, local_buffer):
                # 创建一个NewAttribute对象，并读取其值
                self._new_attribute = objects.NewAttribute()
                self._new_attribute.read(
                    local_buffer,
                    kmip_version=kmip_version
                )
            else:
                # 如果没有NEW_ATTRIBUTE标签，抛出InvalidKmipEncoding异常
                raise exceptions.InvalidKmipEncoding(
                    "The ModifyAttribute request payload encoding is missing "
                    "the new attribute field."
                )

        # 检查是否超过了预期的大小
        self.is_oversized(local_buffer)

    def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Write the data encoding the ModifyAttribute request payload to a
        stream.

        Args:
            output_buffer (stream): A data stream in which to encode object
                data, supporting a write method; usually a BytearrayStream
                object.
            kmip_version (KMIPVersion): An enumeration defining the KMIP
                version with which the object will be encoded. Optional,
                defaults to KMIP 1.0.

        Raises:
            InvalidField: Raised if a required field is missing from the
                payload object.
        """
        local_buffer = utils.BytearrayStream()

        if self._unique_identifier:
            self._unique_identifier.write(
                local_buffer,
                kmip_version=kmip_version
            )

        if kmip_version < enums.KMIPVersion.KMIP_2_0:
            if self._attribute:
                self._attribute.write(
                    local_buffer,
                    kmip_version=kmip_version
                )
            else:
                raise exceptions.InvalidField(
                    "The ModifyAttribute request payload is missing the "
                    "attribute field."
                )
        else:
            if self._current_attribute:
                self._current_attribute.write(
                    local_buffer,
                    kmip_version=kmip_version
                )

            if self._new_attribute:
                self._new_attribute.write(
                    local_buffer,
                    kmip_version=kmip_version
                )
            else:
                raise exceptions.InvalidField(
                    "The ModifyAttribute request payload is missing the new "
                    "attribute field."
                )

        self.length = local_buffer.length()
        super(ModifyAttributeRequestPayload, self).write(
            output_buffer,
            kmip_version=kmip_version
        )
        output_buffer.write(local_buffer.buffer)

    def __repr__(self):
        args = [
            "unique_identifier='{}'".format(self.unique_identifier),
            "attribute={}".format(
                repr(self.attribute) if self.attribute else None
            ),
            "current_attribute={}".format(
                repr(self.current_attribute) if self.current_attribute
                else None
            ),
            "new_attribute={}".format(
                repr(self.new_attribute) if self.new_attribute else None
            )
        ]
        return "ModifyAttributeRequestPayload({})".format(", ".join(args))

    def __str__(self):
        return str(
            {
                "unique_identifier": self.unique_identifier,
                "attribute": str(self.attribute) if self.attribute else None,
                "current_attribute": str(
                    self.current_attribute
                ) if self.current_attribute else None,
                "new_attribute": str(
                    self.new_attribute
                ) if self.new_attribute else None
            }
        )

    def __eq__(self, other):
        if isinstance(other, ModifyAttributeRequestPayload):
            if self.unique_identifier != other.unique_identifier:
                return False
            elif self.attribute != other.attribute:
                return False
            elif self.current_attribute != other.current_attribute:
                return False
            elif self.new_attribute != other.new_attribute:
                return False
            else:
                return True
        else:
            return NotImplemented

    def __ne__(self, other):
        if isinstance(other, ModifyAttributeRequestPayload):
            return not self.__eq__(other)
        else:
            return NotImplemented


class ModifyAttributeResponsePayload(base.ResponsePayload):
    """
    A response payload for the ModifyAttribute operation.

    Attributes:
        unique_identifier: The unique ID of the object on which the attribute
            was set.
        attribute: The newly modified attribute. Used in KMIP 1.0 - 1.4.
    """

    def __init__(self, unique_identifier=None, attribute=None):
        """
        Construct a ModifyAttribute response payload.

        Args:
            unique_identifier (string): The unique ID of the object on
                which the attribute was set. Defaults to None. Required for
                read/write.
            attribute (struct): An Attribute object representing the newly
                modified attribute. Optional, defaults to None. Used in KMIP
                1.0 - 1.4. Required for read/write.
        """
        super(ModifyAttributeResponsePayload, self).__init__()

        self._unique_identifier = None
        self._attribute = None

        self.unique_identifier = unique_identifier
        self.attribute = attribute

    @property
    def unique_identifier(self):
        if self._unique_identifier:
            return self._unique_identifier.value
        return None

    @unique_identifier.setter
    def unique_identifier(self, value):
        if value is None:
            self._unique_identifier = None
        elif isinstance(value, six.string_types):
            self._unique_identifier = primitives.TextString(
                value=value,
                tag=enums.Tags.UNIQUE_IDENTIFIER
            )
        else:
            raise TypeError("The unique identifier must be a string.")

    @property
    def attribute(self):
        if self._attribute:
            return self._attribute
        return None

    @attribute.setter
    def attribute(self, value):
        if value is None:
            self._attribute = None
        elif isinstance(value, objects.Attribute):
            self._attribute = value
        else:
            raise TypeError("The attribute must be an Attribute object.")

    def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Read the data encoding the ModifyAttribute response payload and decode
        it into its constituent parts.

        Args:
            input_buffer (stream): A data stream containing encoded object
                data, supporting a read method; usually a BytearrayStream
                object.
            kmip_version (enum): A KMIPVersion enumeration defining the KMIP
                version with which the object will be decoded. Optional,
                defaults to KMIP 1.0.

        Raises:
            InvalidKmipEncoding: Raised if any required fields are missing
                from the encoding.
        """
        super(ModifyAttributeResponsePayload, self).read(
            input_buffer,
            kmip_version=kmip_version
        )
        local_buffer = utils.BytearrayStream(input_buffer.read(self.length))

        if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_buffer):
            self._unique_identifier = primitives.TextString(
                tag=enums.Tags.UNIQUE_IDENTIFIER
            )
            self._unique_identifier.read(
                local_buffer,
                kmip_version=kmip_version
            )
        else:
            raise exceptions.InvalidKmipEncoding(
                "The ModifyAttribute response payload encoding is missing the "
                "unique identifier field."
            )

        if kmip_version < enums.KMIPVersion.KMIP_2_0:
            if self.is_tag_next(enums.Tags.ATTRIBUTE, local_buffer):
                self._attribute = objects.Attribute()
                self._attribute.read(local_buffer, kmip_version=kmip_version)
            else:
                raise exceptions.InvalidKmipEncoding(
                    "The ModifyAttribute response payload encoding is missing "
                    "the attribute field."
                )

        self.is_oversized(local_buffer)

    def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Write the data encoding the ModifyAttribute response payload to a
        buffer.

        Args:
            output_buffer (buffer): A data buffer in which to encode object
                data, supporting a write method; usually a BytearrayStream
                object.
            kmip_version (enum): A KMIPVersion enumeration defining the KMIP
                version with which the object will be encoded. Optional,
                defaults to KMIP 1.0.

        Raises:
            InvalidField: Raised if a required field is missing from the
                payload object.
        """
        local_buffer = utils.BytearrayStream()

        if self._unique_identifier:
            self._unique_identifier.write(
                local_buffer,
                kmip_version=kmip_version
            )
        else:
            raise exceptions.InvalidField(
                "The ModifyAttribute response payload is missing the unique "
                "identifier field."
            )

        if kmip_version < enums.KMIPVersion.KMIP_2_0:
            if self._attribute:
                self._attribute.write(local_buffer, kmip_version=kmip_version)
            else:
                raise exceptions.InvalidField(
                    "The ModifyAttribute response payload is missing the "
                    "attribute field."
                )

        self.length = local_buffer.length()
        super(ModifyAttributeResponsePayload, self).write(
            output_buffer,
            kmip_version=kmip_version
        )
        output_buffer.write(local_buffer.buffer)

    def __repr__(self):
        args = [
            "unique_identifier='{}'".format(self.unique_identifier),
            "attribute={}".format(
                repr(self.attribute) if self.attribute else None
            )
        ]
        return "ModifyAttributeResponsePayload({})".format(", ".join(args))

    def __str__(self):
        return str(
            {
                "unique_identifier": self.unique_identifier,
                "attribute": str(self.attribute) if self.attribute else None
            }
        )

    def __eq__(self, other):
        if isinstance(other, ModifyAttributeResponsePayload):
            if self.unique_identifier != other.unique_identifier:
                return False
            elif self.attribute != other.attribute:
                return False
            else:
                return True
        return NotImplemented

    def __ne__(self, other):
        if isinstance(other, ModifyAttributeResponsePayload):
            return not self.__eq__(other)
        return NotImplemented
